VB .NET Web Apps

The Strong Name tool provides assemblies with a strong name to guarantee globally uniqueness.

The global assembly cache is a machine-wide accessible store for assemblies specifically designated to be shared by several applications on the computer.

An application must be installed into the Global Assembly Cache you can not simply perform a copy operation.

To deploy a web site you could copy the files to the wwwroot folder on the server but must install an assembly and it must be placed into the Global Assembly Cache.

Ensuring that when the assembly is deployed it does not deploy to the Global Assembly Cache is the opposite of what you want to accomplish.

Component services can be found in the Administrative tools and is the replacement for the MTS environment. Each role configured in Component Services can be assigned user or group accounts from any trusted computer or domain controller.

SQL Server does support role based security in this fashion but it is not the proper technique for assigning role-based security to a component.

You could perform this activity but it is unnecessary and there are techniques built into the component services that already provide this functionality.

If the component is used to solely access the server this technique is useful for a database implementation but doesn't provide for multiple roles nor does it work outside of the context of the database server.

The Windows authentication provider relies upon IIS to perform the required authentication of a client based on a Windows logon process. It authenticates using Windows accounts on a computer or within a domain.

The Passport authentication provider offers a single logon and core profile services for member sites. Used primarily when Windows account information is not available or the same authentication is needed across any of the participating member sites.

The Forms authentication provider makes it possible for the application to collect credentials using an HTML form. It uses cookies as a way of maintaining the logon information within the users Internet cache.

No Authentication (None) would allow all access and is definitely not what is required.

Custom application authentication is far too much effort and is only used in instances where extra authentication measures must be taken as the application executes.

When using impersonation the application relies on the NTFS permissions to secure all files. If those permissions do not permit reading of the file then access would be denied.

Share permissions have no effect when accessing files across the Internet. Share permissions are solely used when access files across a corporate network through the share.

When using impersonation the application relies on the NTFS permissions to secure all files. If those permissions do not permit reading of the file then access would be denied.

Configuring the site in the IIS manager to allow anonymous access could allow a user to access far more files then they should be able to and will not remedy the situation for the files in question.

The processes are business rules which should be separated from the user interface and the data services.

Because the business rules in these processes are not directly related to the data it is unlikely that they belong in stored procedures.

In one component that will be accessed by the Windows-based applications and a second component accessed by the Internet server processed. It is likely unnecessary to use two components in this example as a single component could be used by both application types.

Because this is a three-tier development and the processes are complex it makes more sense to separate the processing into middle tier business rules components.

Code declaration blocks are defined using <script> tags that contain a runat attribute value set to "server" to indicate the code is to be executed at the server. <% Code goes here... %> defines inline code or inline expressions that execute on the server when the page is rendered.

<%-- Code goes here... --%> is a server side comment expression and can not contain code to be executed.

The Object ID tag is used to declare and create COM and .NET objects in a Web Forms page.

The Include will allow for you to insert the contents of a specified file anywhere within an ASP.NET page.

The processes are business rules which should be separated from the user interface and the data services.

Because the business rules in these processes are not directly related to the data it is unlikely that they belong in stored procedures.

In one component that will be accessed by the Windows-based applications and a second component accessed by the Internet server processed. It is likely unnecessary to use two components in this example as a single component could be used by both application types.

Because this is a three-tier development and the processes are complex it makes more sense to separate the processing into middle tier business rules components.

In the DataList Web server control, you set the appearance of items using properties of the ItemStyle objects.

In the DataList Web server control, you set the appearance of selected items using properties of the SelectedItemStyle objects.

Set the ItemTemplate property gets or sets the template for the items in the DataList control it does not directly control the display functionality.

Set the Selected.ItemTemplate property gets or sets the template for the selected items in the DataList control it does not directly control the display functionality.

Set the Separator.Template property interacts with the template of the separator between each item in the DataList control and does not directly control display functionality.

Set the Separator.Style property interacts with the style properties of the separator between each item in the DataList control.

Once declared a web controls properties can be set using the declared name.

WebUserControl1.Visible = True is the generic class name for the control and cannot be directly interacted with.

Like other controls a web form's controls visibility can be altered using the Visible property.

The Visible property should be used for visibility the Show method is used for formsand the generic WebUserControl1 should not be directly interacted with.

The Session_OnStart event is fired when a user accesses an ASP.NET application it is used to provide initialization of user activity.

The Application_OnStart event fires only once during the life of an application and therefore is unsuitable for user initialization.

This type of initialization is not suitable in this instance and would be best used to initialize elements of a Windows form.

In Visual Basic .NET, initialization code can be added to a form constructor (Sub New()) after the call to InitializeComponent().

The Assembly Linker generates a file with an assembly manifest from multiple files that are modules or resource files.

The Resource File Generator converts .txt files and .resx files to common language runtime binary. resources files.

The Isolated Storage tool lists or removes existing stores for a user.

The Installer tool allows you to install server resources by executing the installer components.

The MSIL Assembler generates a portable executable (PE) file from MSIL assembly language.

The License Compiler reads text files containing license data producing .licenses files that can be embedded in an executable as a resource.

Web user controls are easy to make, but they can be difficult to use for the inexperienced developer.

Web custom controls are compiled code, which makes them easier to use but more difficult to create then web user controls.

Creating an ActiveX control to encapsulate the functionality is a good solution when working on the client side, yet the indication of server side controls makes it a poor choice.

ASP.NET Web services rely on the System.Xml.Serialization.XmlSerializer class to marshal data to and from SOAP messages at runtime and are an application specific that could not provide the desired functionality.

Web User Controls have limited design support while Web Custom Controls have full visual design support. Web user controls have limited support for consumers who use a visual design tool while Web custom controls have full visual design tool support for consumers. Web user controls require a separate copy of the control in each application while only a single copy of a Web custom control is required, in the global assembly cache. Web user controls cannot be added to the Toolbox in Visual Studio while Web custom controls can be added to the Toolbox.

Web user controls cannot be added to the Toolbox in Visual Studio while Web custom controls can be added to the Toolbox.

Web user controls require a separate copy of the control in each application while only a single copy of a Web custom control is required, in the global assembly cache.

Web user controls have limited support for consumers who use a visual design tool while Web custom controls have full visual design tool support for consumers.

The @Page directive defines page-specific attributes used by the ASP.NET.

The whole purpose behind the single runtime engine is to allow you to combine languages and create complete systems that are not language specific.

The Global.asa file supplies information for the entire application, not a single page. The @Page directive defines page-specific attributes used by the ASP.NET.

The Web.config file is an XML file that describes and controls the configuration of the application.

Use the Response.Write method to sent HTP output to the user's browser.

<% Response.Redirect %> OutputToBrowser would redirect the user to an alternate site stored in the variable and the variable should be included in the server directive.

The built variable should be included inside the server directive

To create and raise an event declare the event and the parameters (if any) that it uses.

Friend WithEvents MyComponentImplemented As MyComponent
Protected Sub MyComponentImplemented_LogonCompleted(UserName As String) Handles MyComponent.LogonCompleted 'Implementation code here
EndSub
is a possible client side code for the ASP.NET application and not the correct component code.

AddHandler MyComponent.LogonCompleted, AddressOf Me.MyEventHandler
Sub MyEventHandler() ' Implementation Code
End Sub
is possible client side code for the ASP.NET application and not the correct component code.

Sub TestEvents() Dim Obj As New MyComponent
AddHandler Obj.LogonCompleted, AddressOf EventHandler
Obj.LogonDone() RemoveHandler Obj.Ev_Event, AddressOf EventHandler
End Sub
is client side code that you might find in the ASP .NET application that starts and stops event handling.

This is client side code that you might find in the ASP .NET application that starts and stops event handling.

Friend WithEvents MyComponentImplemented As MyComponent
Protected Sub MyComponentImplemented_LogonCompleted(UserName As String) Handles MyComponent.LogonCompleted
'Implementation code here
End Sub
is possible client side code for the ASP.NET application for trapping the event. However, once the event is fired the application will still handle future events.

AddHandler MyComponent.LogonCompleted, AddressOf Me.MyEventHandler

Sub MyEventHandler()
' Implementation Code

End Sub
is possible client side code for the ASP.NET application for trapping the event. However, once the event is fired the application will still handle future events.

Event LogonCompleted(UserName As String)

Sub LogonDone
RaiseEvent LogonCompleted("Billy Bean")

End Sub
is an example of what you might find in the component itself.

The contents command creates a graphical table of contents that displays a specified contents file.

The HHVersion command is used to display the version number of the HTML Help ActiveX control in a dialog box.

The Index command is used to creates a graphical index that displays a specified index file.

The Klink command is used to provide a Keywords list.

The Implements statement allows you to specify one or more interfaces, or interface members, that will be implemented in the class or structure definition in which it appears.

Both new classes should be based on the Customer class. The Service customer is not intended to be a subclass of the product customer.

The Implements statement can be used instead of a manual copy operation because it allows you to specifies one or more interfaces, or interface members, that will be implemented in the class or structure definition in which it appears.

The Inherits statement uses the two new classes to inherit the attributes, fields, properties, methods, and events from the customer class.

The implements statement only inherits the interfaces not the code.

The imports statement allows you to imports namespace names from referenced projects and assemblies. Also imports namespace names defined within the same project as the file in which the statement appears allowing a shorter technique to coding.

The interface statement allows you to create a template of a class with no implementation code.

The likely cause of the problem is variable narrowing. Strict should be off if the narrowing will not cause loss of data. If you set strict off then you are allowed to perform calculations that store the result into variables of a smaller size (narrowing).

The error is likely occurring because strict conversion is on, in which case you need not change any of the data types if the narrowing will not cause loss of data.

Set Option Explicit on will only force you to declare variables before their use that the code is already doing.

You can convert an array type to a different array type provided you have the same number of elements in each array, variable types must be reference types, widening or narrowing must be available (the types must have something in common)

"Myarray is not declared" would be right if Option Explicit were off.

Myarray is an object array is fine providing the widening or narrowing is possible. In other words it is possible to store a sting into an object.

'Option Strict is set on' is not right because the conversion would be a widening of the data not a narrowing.

Enum is used at a module, class, or structure level to declare enumeration constants and define the values of its members.

Const is used for declaring singular constants, an enumeration must be used for multiple values.

Public Sub InterfaceColors
Const MistyRose = &HE1E4FF&
Const SlateGray = &H908070&
Const DeepSkyBlue = &HFFBF00&
Const ForestGreen = &H228B22&
End Sub
in theory would work. However, you would have to declare separate constant for each color that was created in the future. This could be an arduous update task if the colors every change.

Public Function InterfaceColors( Choice as string) As Color
Select Case Choice
Case "MistyRose" InterfaceColors = &HE1E4FF&
Case "SlateGray"
InterfaceColors = &H908070&
Case "DeepSkyBlue"
InterfaceColors = &HFFBF00&
Case Else
InterfaceColors = &H228B22&
End Select
End Function'
is a rather lucrative approach that may work but would require a lot of supporting code.

When you create and code a web form it generated two separate files one is the form descriptor (aspx) and the other contains the code applied against the form (aspx.vb)

The @Page directive defines page-specific attributes used by the ASP.NET page parser and compiler.

The EnableViewState property will get or set a value indicating whether the server control persists its view state, and the view state of any child controls it contains, to the requesting client. This is an option of a control and will not effect the parsing of the page.

<%@ Reference Control="MyControl.ascx" %> indicates that another user control or page source file should be dynamically compiled and linked against the page in which this directive is declared.

DataBinder.Eval will evaluate late-bound data-binding expressions and optionally formats the result as a string.

Try and accomplish a number of operations during a single trip to the server. Multiple trips consume considerable resources. State information maintains data about the application and session as interaction occurs. By minimizing or eliminating its use when not needed resource usage can be much more efficient. Server-side controls consume resources at the server if a client-side operation can perform the same task it is much more efficient.

Use server-side controls wherever possible.

The appropriate model would use a DataSet to access SQL server and relate two DataTable objects with the ForeignKeyConstraint.

The hierarchy of objects should put two DataTable objects into a single DataSet object.

There is no need for two DataSet objects. This process would normally be performed over one connection with a singular DataSet.

A ConstraintCollection is normally used to set up a list of constraints for a single DataTable.

The default will allow cascading deletions. To prevent this you must change the default value.

A cascading deletion is the default value of the DeleteRule in a ForeignKeyConstraint object.

Setting the PrimaryKey property of the Invoice table to a known column will allow for uniqueness but will not prevent cascading actions. Setting the PrimaryKey property of the InvoiceDetails table to a combination of known columns will allow for uniqueness but will not prevent cascading actions.

The Constraint property of the table will allow you to obtain a list of table level constraints. It does not control cascading actions.

The Web Services Description Language tool can generate code for XML Web services and XML Web service clients from the file.

The Web Services Discovery tool is used to assist in locating servers where XML Web services are deployed.

The Windows Forms Resource Editor helps localize Windows Forms. The XML Schema Definition tool generates XML schema or common language runtime classes.

The Isolated Storage tool lists existing stores for the current user.

The Assembly Cache Viewer allows you to view and manipulate the contents of the global assembly cache.

The Fill method returns the column names, types and data to populate the rows of the tables in the DataSet. The Update method of the DataAdapter is called to send changes from a DataSet back to the data source.

DataAdapter.Fetch gets a copy of the DataSet containing all changes made to it since it was last loaded, or since AcceptChanges was called, but does not send the changes to the source.

DataSet.HasChanges is used to determine whether a DataSet has changes or not.

DataSet.Update is used to save the changes (or DataAdater.UpdateCommand if performed through SQL)

Provider=SQLOLEDB;Data Source=DMZSQL1\External;Initial Catalog=Customer;Integrated Security=SSPI

You must include the instance name as part of the data source along with the computer name.

The catalog entry is only the name of the database being accessed.

The provider is not an optional entry.

The transform method allows the transformation of XML data within an ASP.NET application.

Retrieving XML data from a SQL Server database is easily performed but is not the code provided. An XSL style sheet is used against an XML document to provide HTML output.

Sending XML data to a SQL Server database is possible but requires much more significant coding and is not the code example.

An XSL style sheet is used against an XML document to provide HTML output.

The provided code will use one of the overloaded versions of WriteXml to send data to a file in XML form. Private Sub WriteXmlToFile(thisDataAdapter As DataAdapter)
Dim filename As String = "myXmlDoc.xml"
Dim myFileStream As New System.IO.FileStream _
(filename, System.IO.FileMode.Create)
Dim myXmlWriter As New System.Xml.XmlTextWriter _
(myFileStream, System.Text.Encoding.Unicode)
thisDataAdapter.WriteXml(myXmlWriter)
myXmlWriter.Close()
End Sub
uses a data adapter when a data set would be the requirement for the functionality requested.

Private Sub WriteXmlToFile(thisDataSet As DataASet)
FileOpen(1, "c:\myXMLData.txt", OpenMode.Binary)
FilePutObject(1, thisDataSet)
FileClose(1)
End Sub
will create a standard text file. It will not generate XML data.

Sub WriteXMLToFile(thisDataSet As DataSet)
FileOpen(1, "C:\XMLData.txt", OpenMode.Binary)
FilePut(1, thisDataSet)
FileClose(1)
End Sub
will create a standard text file. It will not generate XML data.

This is the correct code because the transaction is implemented properly on the connection object.

[B: is incorrect because the transaction implements the transaction - not the connection.]

[C: is incorrect because the transaction implements the transaction - not the connection.]

[D: is incorrect because the command implements the transaction - not the connection.]

A stored procedure will allow the fastest possible return of the data to the user. The Input parameter will allow for the user to select the desired data.

A stored procedure is the correct mechanism but you should as well allow the stored procedure to perform the data filtering.

An adhoc query of this nature would not provide as good performance as other mechanisms.

Having a query retrieve all data from the table using a Select operation and having the application filter the data is the worst of the proposed solutions. It is in most cases sending far too much data over the Internet.

Use one of the overloaded versions of the XPathDocument constructor to generate an XML document from a query. The query will be stored in a hidden element on the form, sqlQueryBuilt that has been concatenated from user input.

Dim mySelectQuery as string = Request.Form("sqlQueryBuilt")

Dim myConnectString as string = "server=localhost;Integrated Security=True;database=myDatabase"

Dim sqlConn as SqlConnection = new SqlConnection( myConnectString )

sqlConn.Open()

Dim sqlComm as SqlCommand = new SqlCommand(mySelectQuery , sqlConn)

Dim reader as XmlTextReader = CType(sqlComm.ExecuteXmlReader(),XmlTextReader)

Dim doc as XMLDocument = new XMLDocument
will create a new XML document in memory it will not produce the functionality requested.



Dim mySelectQuery as string = Request.Form("sqlQueryBuilt") & " For XML Auto"

Dim myConnectString as string = "server=localhost;Integrated Security=True;database=myDatabase"

Dim sqlConn as SqlConnection = new SqlConnection( myConnectString )

sqlConn.Open()

Dim sqlComm as SqlCommand = new SqlCommand( mySelectQuery , sqlConn)
would create a recordset containing XML data and not provide the functionality requested.



Dim mySelectQuery as string = Request.Form("sqlQueryBuilt") & " For XML Auto"

Dim myConnectString as string = "server=localhost;Integrated Security=True;database=myDatabase"

Dim sqlConn as SqlConnection = new SqlConnection( myConnectString )

sqlConn.Open()

Dim sqlComm as SqlCommand = new SqlCommand( mySelectQuery , sqlConn)

Dim reader as XmlTextReader =_
CType(sqlComm.ExecuteXmlReader(),XmlTextReader)
Dim doc as XPathDocument = new XPathDocument(reader, XmlSpace.Preserve)
would create an XML document containing the data from an XML recordset and would be cumbersome to work with on the browser.

The input type controls what is displayed in the text box as the user types. Possible values include "text" for normal display and "password" to not displaythe text as it is typed.

Web server controls do supply much more functionality but are not required in this instance.

No additional coding is needed the standard functionality of the HTMLInputTextControl can already provide the desired behavior.

Besides, server side code could not be used without round trips for each keystroke.

Use the WriteXML method of the DataSet object to write an XML representation. Since you have already standardized on a single schema it is not necessary to supply the schema with the XML data.

Since you have already standardized on a single schema it is not necessary to supply the schema with the XML data. A DiffGram is an XML format that is used to identify current and original versions of data elements and would not be needed in this instance.

The WriteXMLSchema creates a schema file from the DataSet. We do not need the schema in this instance and the method does not produce the required XML data.

Use the ReadXML method of the DataSet object to read an XML representation from a file. Since you have already standardized on a single schema any schema presented in the file can be ignored and the schema can be inferred from the data.

Since you have already standardized on a single schema it is not necessary to read the schema and it was not given that the file would contain schema information.

A DiffGram is an XML format that is used to identify current and original versions of data elements and would not be needed in this instance.

The fragment option continues reading multiple XML fragments until the end of the stream is reached. Fragments do not apply in this instance.

To insert a record create a parameterized insert query to send the data to the archive table on an SQLCommand object.

Parameters should be set before the connection is opened.

An update query would not add a new row to the archive table but would change an existing one. Also, parameters should be set before the connection is opened.

The listener will allow you to react with the application event log for the reporting of debug information.

The DefaultTraceListener sends output to the Windows system debugger.

TextWriterTraceListener allows you to create a text based debug file.

The Microsoft .NET SDK debugger is an interim tool for debugging applications written and compiled for the Microsoft .NET runtime and provides information in its own interface.

Throw errors as System.Exception types is a dialogue box style error message.

The Windows Event log can be used for the recording of application level errors. Using the .NET classes found in the namespace System.Diagnostics you can write messages to the Windows Event log. The web.config file contains a tag that can be used to apply exception handling and/or redirection.

Implement the Page_error evento handler is not suitable for this application, as the Page_Error event handler requires a full implementation to render the page completely by itself.

Use of the SOAP protocol allows for data to be encoded in XML and transmitted over the Internet.

A page trace is used in applications debugging, not for error handling in production.

To allow stepping through the class build the .dll file with the debug options turned on.

The source code is not needed unless Joe had desired to make alterations to the class.

The person that builds the class library is not relevant to this solution. It is more in the manner in which the library is built.

Joe does not need access to the code unless he had desired to make changes to the class.

To set the level of your TraceSwitch, you will need to edit the configuration file that corresponds to the name of your application.

The Web.config file is an XML file that controls the configuration of the application and is automatically generated when the site is unpacked. It is intended to be a deployment file not used for debugging.

There is a single Machine.config file for all sites deployed on a server, it is a deployment file that is not intended to be used for debug operations.

The solution file is used to track the contents of a Visual Studio .NET application. It does not control TraceSwitch settings.

The project file is used to keep track of the contents of the project and does not control TraceSwitch settings.

The Locals window displays variables local to the current context.

The properties window allows you to set values of the properties of forms and controls etc while creating an application.

Resource view displays the resource files included in your projects.

The Class View allows you to create virtual folders to organize frequently used symbols.

The task list is like a common "To Do" list and also will contain errors that occur during the building of an application.

The Object browser allows you to view objects referenced by your application.

The WriteIf will output information to the trace listener when a condition is true. Unlike the WriteLineIf method it creates only a partial line that can be added to with future trace.write methods.

The assert operation will write to the listener if the condition is not met, in this case it is the opposite behavior that what we are looking for.

Debug.WriteIf(errorFlag, "Error in AppendData procedure") will not write the information to the listener and is used for debugging while in the Visual Studio .NET IDE.

Trace.Write("Error in AppendData procedure") is an unconditional write that would fire even if there was no error.

The WriteLineIf method appends a carriage return so future writes would be on a new line.

Trace.WriteLine("Error in AppendData procedure.") would fire regardless of whether or not there was an error and it also writes a full line with a carriage return appended to the end.

You will usually get better performance by testing a BooleanSwitch first and then calling the general Trace.Write method as opposes to using a WriteLineIf operation.

Though Trace.WriteLineIf(errorFlag.Enabled, "Error 42 Occurred") code does properly implement the test it is not necessarily the best performing mechanism.

The WriteIf will only write a partial line to allow future writes to append to it.

Trace.WriteLine("Error 42 Occurred") is an unconditional write operation that will fire regardless of the state of the Boolean switch.

A third party such as Verisign issues certificates that can be applied to applications to validate the application and its developer. You use the Signcode tool to apply an Authenticode digital signature.

The customer is unlikely (or too foolish) to trust a certificate issued by the same company that performs the development.

The Strong Name tool signs assemblies with strong names for key management, signature generation, and signature verification. A strong name should be generated to guarantee uniqueness of an application not authenticity.

The Type Library Exporter generates a type library that describes the types defined in an assembly. It is used an installation assistant for allowing types to be referenced.

Merge modules are used to package components rather than complete applications. Use of your component in applications can include your merge module in their .msi files to ensure your component is installed with their other application files.

Merge modules are used to package components rather than complete applications.

For a component to be installed and shared by multiple applications a merge module should be included in the deployment project.

A web setup project should be used to deploy and ASP.NET application.

The Execute method calls an .asp or .aspx file, and processes it as a standard procedure call.

The Abandon method destroys all the objects stored in a Session object and releases all resources. It is an alternative way to clean up resources, but does not provide the functionality requested.

The AppendToLog method adds a string to the end of the Web server log entry for the request.

The BinaryRead method retrieves data sent to the server from the client as part of a POST request. This method retrieves the data from the client and stores it in a SafeArray. This may be an alternative to the requested functionality but does not allow processing to continue in another .aspx page.

To allow for connection pooling, a single connection can be shared by a single user account.

Using the SA account in this manner is extremely insecure and allows a user to access elements at an administrator's level through the application.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsentpro/html/veconusingconnectionpooling.asp

The CultureInfo class is used to represent information about a specific culture. The information includes formatting of dates and sorting strings among other information.

Since separate deployments are being used multiple files of all types will be needed. The CultureInfo class is used to represent information about a specific culture. The information includes formatting of dates and sorting strings among other information.

The DesignTimeDataClass provides methods that can be used by control designers to generate sample data for data bound properties at design time. It has no effect on the separate deployments.

The System.Web.Services.Description namespace consists of classes that enable you to describe an XML Web service.

The predefined CultureInfo names and identifiers are accepted and used by the class in the System.Globalization namespace.

The Germany code should be de-DE, all of the remaining are correct.

Each of the codes must be correct for the regions; correct codes are en-US, en-AU, en-CA and de-DE.

Though each of the three English-speaking countries use similar languages, other cultural elements are significantly different.

You can ensure that a name is globally unique by signing an assembly with a strong name.

The File Signing tool signs a portable executable file with an Authenticode digital signature. You can sign either a component or an assembly. This will help secure the assembly but no guarantee uniqueness.

The Certificate Verification tool will check the validity of a file that has been signed with an Authenticode certificate.

The Native Image Generator creates a native image from a managed assembly and installs it into the native image cache on the local computer. It will aid in performance but not guarantee uniqueness.

The Global Assembly Cache tool allows you to view and manipulate the contents of the global assembly cache and download cache. Contents of the global assembly cache are available to all applications.

Use the .NET Framework tool against the assembly. The .NET Framework Configuration tool is a Microsoft Management Console snap-in that allows you to manage and configure assemblies once they have already been placed into the global assembly cache by using the Global Assembly Cache tool.

To be available to all applications you must place the assembly into the global assembly cache and you should as well give it a strong name.

This tool is used against .DLL and .EXE files. You need to place the assembly in to the global assembly cache for it to be available to all applications.

The Web.config file is an XML file that describes and controls the configuration of the application.

Altering the settings of a Web.config file should be performed with caution. Your settings may affect another application.

The custom errors configuration section of the Web.config file allows you to customize any of the standard browser messages.

The Machine.config file could potentially effect all applications on the server.

Alerts respond to messages placed into the operating system event log and would not be appropriate for Internet messages.

A page is not being posted as an error has occurred in locating the page.

The SQLException class handles all errors that are thrown from the result of processing on the server. A Try ... Catch block traps these errors in an efficient manner.

Although the SQLException class handles all errors that are thrown from the result of processing on the server. On Error exception handling is not the most efficient and structured techniques for error handling.

The DataException class handles all errors that are thrown from the result of ADO.NET processing not as a result of server side processing. On Error exception handling is not the most efficient and structured techniques for error handling.

The likely cause of the problem is variable narrowing. Strict should be off if the narrowing will not cause loss of data. If you set strict off then you are allowed to perform calculations that store the result into variables of a smaller size (narrowing).

The error is likely occurring because strict conversion is on, in which case you need not change any of the data types if the narrowing will not cause loss of data.

Set Option Explicit on will only force you to declare variables before their use that the code is already doing.

Enum is used at a module, class, or structure level to declare enumeration constants and define the values of its members.

Const is used for declaring singular constants, an enumeration must be used for multiple values.

Public Sub InterfaceColors
Const MistyRose = &HE1E4FF&
Const SlateGray = &H908070&
Const DeepSkyBlue = &HFFBF00&
Const ForestGreen = &H228B22&
End Sub
in theory would work. However, you would have to declare separate constant for each color that was created in the future. This could be an arduous update task if the colors every change.

Public Function InterfaceColors( Choice as string) As Color
Select Case Choice
Case "MistyRose" InterfaceColors = &HE1E4FF&
Case "SlateGray"
InterfaceColors = &H908070&
Case "DeepSkyBlue"
InterfaceColors = &HFFBF00&
Case Else
InterfaceColors = &H228B22&
End Select
End Function'
is a rather lucrative approach that may work but would require a lot of supporting code.